{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding Monte Carlo Tree Search (MCTS): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction: Search and Planning in RL](#introduction)\n",
    "- [What is MCTS?](#what-is-mcts)\n",
    "  - [Core Idea: Guided Simulation](#core-idea)\n",
    "  - [MCTS vs. Other Search Methods](#mcts-vs-other-search-methods)\n",
    "- [Why MCTS? Advantages](#why-mcts)\n",
    "- [Where and How MCTS is Used](#where-and-how-mcts-is-used)\n",
    "- [Mathematical Foundation of MCTS](#mathematical-foundation-of-mcts)\n",
    "  - [Tree Structure: Nodes and Edges](#tree-structure)\n",
    "  - [The Four Steps of MCTS Iteration](#the-four-steps)\n",
    "    - [1. Selection](#1-selection)\n",
    "    - [2. Expansion](#2-expansion)\n",
    "    - [3. Simulation (Rollout)](#3-simulation-rollout)\n",
    "    - [4. Backpropagation](#4-backpropagation)\n",
    "  - [Upper Confidence Bound for Trees (UCT/UCB1)](#uct-ucb1)\n",
    "  - [Rollout Policy](#rollout-policy)\n",
    "- [Step-by-Step Explanation of MCTS (for Action Selection)](#step-by-step-explanation-of-mcts)\n",
    "- [Key Components of MCTS](#key-components-of-mcts)\n",
    "  - [Tree Nodes](#tree-nodes)\n",
    "  - [Selection Policy (UCB1)](#selection-policy-ucb1)\n",
    "  - [Expansion Strategy](#expansion-strategy)\n",
    "  - [Simulation (Rollout) Policy](#simulation-rollout-policy)\n",
    "  - [Backpropagation Update](#backpropagation-update)\n",
    "  - [Simulation Budget](#simulation-budget)\n",
    "  - [Final Action Selection](#final-action-selection)\n",
    "  - [Environment Model/Simulator](#environment-modelsimulator)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Custom Grid World](#practical-example-custom-grid-world)\n",
    "  - [Why Grid World for MCTS?](#why-grid-world)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Custom Environment](#creating-the-custom-environment)\n",
    "- [Implementing the MCTS Algorithm](#implementing-the-mcts-algorithm)\n",
    "  - [Defining the MCTS Node](#defining-the-mcts-node)\n",
    "  - [Selection Function (Best UCB Child)](#selection-function-best-ucb-child)\n",
    "  - [Expansion Function](#expansion-function)\n",
    "  - [Simulation (Rollout) Function](#simulation-rollout-function)\n",
    "  - [Backpropagation Function](#backpropagation-function)\n",
    "  - [Main MCTS Search Function](#main-mcts-search-function)\n",
    "  - [Choosing the Best Action After Search](#choosing-the-best-action-after-search)\n",
    "- [Running MCTS as a Planner](#running-mcts-as-a-planner)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Interaction Loop using MCTS](#interaction-loop-using-mcts)\n",
    "- [Visualizing the Process](#visualizing-the-process)\n",
    "  - [Visualizing an Agent's Path](#visualizing-an-agents-path)\n",
    "- [Analyzing the Learned Policy (Optional Visualization)](#analyzing-the-learned-policy-optional-visualization)\n",
    "- [Common Challenges and Extensions of MCTS](#common-challenges-and-extensions-of-mcts)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction: Search and Planning in RL\n",
    "\n",
    "While many Reinforcement Learning algorithms learn policies or value functions directly from experience (model-free), another powerful approach involves **planning**. Planning methods use a model of the environment (either known beforehand or learned) to simulate future possibilities and make informed decisions. Monte Carlo Tree Search (MCTS) is a highly successful planning algorithm that intelligently explores the potential future trajectories from the current state.\n",
    "\n",
    "Unlike algorithms like DQN or PPO which produce a policy applicable to *any* encountered state, MCTS is typically used *online*. Given a current state, it performs a search to determine the best *immediate* action, then discards the search tree (mostly) and repeats the process from the next state.\n",
    "\n",
    "## What is MCTS?\n",
    "\n",
    "Monte Carlo Tree Search is a best-first search algorithm guided by the results of random simulations (Monte Carlo rollouts). It incrementally builds a search tree where nodes represent states and edges represent actions. It doesn't require an explicit evaluation function for states but instead estimates the value of states and actions within the tree based on the outcomes of simulations initiated from them.\n",
    "\n",
    "### Core Idea: Guided Simulation\n",
    "MCTS iteratively simulates trajectories through the state space. Instead of exploring randomly or exhaustively, it uses the statistics gathered from previous simulations (like visit counts and average rewards) to guide the search towards more promising areas of the state-action space while still ensuring some level of exploration.\n",
    "\n",
    "### MCTS vs. Other Search Methods\n",
    "- **vs. Minimax/Alpha-Beta:** MCTS doesn't require evaluating all possible game states up to a certain depth. It samples trajectories, making it suitable for domains with huge branching factors (like Go).\n",
    "- **vs. Dynamic Programming:** DP requires a full model and iterates over the entire state space. MCTS focuses search effort starting from the current state and doesn't need global iterations.\n",
    "- **vs. Model-Free RL:** MCTS is a planning algorithm that requires a model (or simulator access). Model-free RL learns directly from real interactions.\n",
    "\n",
    "## Why MCTS? Advantages\n",
    "\n",
    "1.  **Anytime Algorithm:** MCTS can be stopped at any time (given a computational budget) and will provide the best action found so far. More computation generally leads to better decisions.\n",
    "2.  **Asymmetric Tree Growth:** It naturally focuses computational effort on more promising branches of the search tree.\n",
    "3.  **No Heuristic Evaluation Function Needed (for search):** Node values are estimated via simulations, avoiding the need to hand-craft heuristics (though good rollout policies can help).\n",
    "4.  **Parallelizable:** The independent simulations within an iteration can often be parallelized.\n",
    "\n",
    "## Where and How MCTS is Used\n",
    "\n",
    "MCTS gained widespread fame for its success in computer Go (AlphaGo, AlphaZero), but it's applicable to a wide range of problems:\n",
    "\n",
    "1.  **Game Playing:** Go, Chess, Shogi, Hex, and many other board games, as well as video games.\n",
    "2.  **Planning Problems:** Robotics, scheduling, general decision-making problems where a simulator is available.\n",
    "3.  **Integration with Deep Learning:** AlphaGo/AlphaZero combined MCTS with deep neural networks (learned policy and value functions) to guide the search and evaluate positions, achieving superhuman performance.\n",
    "\n",
    "MCTS is particularly effective when:\n",
    "- The state space is large or infinite.\n",
    "- The branching factor (number of possible actions) is large.\n",
    "- A simulator or forward model of the environment is available.\n",
    "- An exact evaluation function is unknown or hard to compute.\n",
    "- Decisions need to be made online with a limited computational budget per decision.\n",
    "\n",
    "## Mathematical Foundation of MCTS\n",
    "\n",
    "### Tree Structure: Nodes and Edges\n",
    "- **Nodes:** Represent states in the environment.\n",
    "- **Edges:** Represent actions taken from a state (parent node) leading to a potential next state (child node).\n",
    "- **Node Statistics:** Each node $s$ typically stores:\n",
    "    - $N(s)$: Visit count (how many simulations passed through this node).\n",
    "    - $W(s)$: Total accumulated reward (or value) from simulations passing through this node.\n",
    "    - $Q(s) = W(s) / N(s)$: Average value estimate for the node.\n",
    "- **Edge Statistics:** Each edge $(s, a)$ leading out of node $s$ may store:\n",
    "    - $N(s, a)$: Visit count for taking action $a$ from state $s$.\n",
    "    - $W(s, a)$: Total reward from simulations initiated after taking action $a$ from state $s$.\n",
    "    - $Q(s, a) = W(s, a) / N(s, a)$: Average value estimate for taking action $a$ in state $s$.\n",
    "\n",
    "### The Four Steps of MCTS Iteration\n",
    "Each iteration of MCTS, starting from the root node (current state), consists of four phases:\n",
    "\n",
    "1.  **Selection:**\n",
    "    - Start at the root node.\n",
    "    - Recursively select child nodes based on a tree policy that balances exploration and exploitation until a leaf node (a node not fully expanded or a terminal node) is reached.\n",
    "    - A common tree policy is UCT (Upper Confidence Bound for Trees), based on UCB1.\n",
    "\n",
    "2.  **Expansion:**\n",
    "    - If the selected leaf node $L$ is not terminal and not fully expanded (i.e., there are untried actions from state $L$), choose one untried action $a$.\n",
    "    - Simulate taking action $a$ using the environment model/simulator to get the next state $s'$.\n",
    "    - Add a new child node representing $s'$ to the tree, connected to $L$ by the edge $a$.\n",
    "    - The newly added node becomes the node for the Simulation phase.\n",
    "\n",
    "3.  **Simulation (Rollout):**\n",
    "    - From the newly expanded node (or the selected leaf node if it was terminal or fully expanded), simulate a complete episode (or until a maximum depth or discount horizon) using a *rollout policy* (often simple, e.g., random actions).\n",
    "    - Collect the total discounted reward $R$ obtained during this simulation.\n",
    "\n",
    "4.  **Backpropagation:**\n",
    "    - Update the statistics ($N$ and $W$) of all nodes and edges visited during the Selection and Expansion phases using the simulation result $R$.\n",
    "    - For each node $n$ on the path from the root to the simulated node:\n",
    "        - Increment $N(n) \\leftarrow N(n) + 1$.\n",
    "        - Update $W(n) \\leftarrow W(n) + R$ (or update based on whose turn it is in games).\n",
    "    - Update edge statistics similarly if stored.\n",
    "\n",
    "### Upper Confidence Bound for Trees (UCT/UCB1)\n",
    "During the Selection phase, the action $a$ leading from node $s$ to child $s'$ is typically chosen to maximize the UCB1 formula:\n",
    "$$ UCT(s, a) = Q(s, a) + C \\sqrt{\\frac{\\ln N(s)}{N(s, a)}} $$\n",
    "Where:\n",
    "- $Q(s, a)$ is the current average value (exploitation term).\n",
    "- $N(s)$ is the visit count of the parent node $s$.\n",
    "- $N(s, a)$ is the visit count of the edge (or child node after taking action $a$).\n",
    "- $C$ is an exploration constant (hyperparameter) balancing exploitation and exploration. Higher $C$ encourages exploring less visited actions.\n",
    "If $N(s, a) = 0$, the UCB value is treated as infinite to ensure unvisited actions are selected first.\n",
    "\n",
    "### Rollout Policy\n",
    "The policy used during the Simulation phase. It should be computationally cheap. Common choices:\n",
    "- **Random Policy:** Select actions uniformly at random.\n",
    "- **Simple Heuristic:** A fast, problem-specific heuristic policy.\n",
    "- **Learned Policy:** A lightweight policy learned separately (less common in basic MCTS).\n",
    "The quality of the rollout policy affects the accuracy of the value estimates obtained from simulations.\n",
    "\n",
    "## Step-by-Step Explanation of MCTS (for Action Selection)\n",
    "\n",
    "Given a current state $s_{root}$ and a simulation budget (e.g., number of iterations $N_{sim}$):\n",
    "\n",
    "1.  **Initialize**: Create a root node for $s_{root}$.\n",
    "2.  **Loop** for $i = 1$ to $N_{sim}$:\n",
    "    a.  **Selection**: Start from $s_{root}$. Traverse the tree using UCT to select actions until a leaf node $L$ is reached.\n",
    "    b.  **Expansion**: If $L$ is expandable, choose an untried action $a$, create a new child node $C$ corresponding to the state resulting from $(L, a)$. Set the simulation start node to $C$.\n",
    "    c.  If $L$ was already fully expanded or terminal, set the simulation start node to $L$.\n",
    "    d.  **Simulation**: From the simulation start node's state, run a rollout using the rollout policy until termination or max depth. Record the total reward $R$.\n",
    "    e.  **Backpropagation**: Update visit counts ($N$) and total values ($W$) for all nodes/edges on the path from the root to the simulation start node using the reward $R$.\n",
    "3.  **Choose Action**: After $N_{sim}$ iterations, select the action $a^*$ corresponding to the edge from the root node with the highest visit count $N(s_{root}, a^*)$ (or sometimes highest value $Q(s_{root}, a^*)$).\n",
    "4.  Return $a^*$.\n",
    "\n",
    "## Key Components of MCTS\n",
    "\n",
    "### Tree Nodes\n",
    "- Store state, parent/child links, visit count $N$, total value $W$.\n",
    "\n",
    "### Selection Policy (UCB1)\n",
    "- Balances exploring less-visited actions and exploiting high-value actions during tree traversal.\n",
    "\n",
    "### Expansion Strategy\n",
    "- How new nodes are added (typically one per iteration for an untried action).\n",
    "\n",
    "### Simulation (Rollout) Policy\n",
    "- Fast policy used to estimate value from unexpanded nodes (e.g., random).\n",
    "\n",
    "### Backpropagation Update\n",
    "- How simulation results update node statistics.\n",
    "\n",
    "### Simulation Budget\n",
    "- Number of iterations/simulations performed per decision (controls thinking time).\n",
    "\n",
    "### Final Action Selection\n",
    "- How the best action is chosen after the search (e.g., most visited child).\n",
    "\n",
    "### Environment Model/Simulator\n",
    "- Needed to predict the outcome $(s', r)$ of taking action $a$ in state $s$ during Expansion and Simulation.\n",
    "\n",
    "### Hyperparameters\n",
    "- Exploration constant $C$ in UCB1.\n",
    "- Simulation budget (iterations or time).\n",
    "- Discount factor $\\gamma$ (if rollouts are discounted).\n",
    "\n",
    "## Practical Example: Custom Grid World\n",
    "\n",
    "### Why Grid World for MCTS?\n",
    "As discussed, the discrete state space, clear actions, and readily available perfect model (the environment code itself) make it ideal for illustrating the MCTS steps without confounding factors. We can see how the tree explores paths and uses simulated rewards to guide action selection.\n",
    "\n",
    "**Environment Description:** (Using Tabular Version)\n",
    "- State: `(row, col)` tuple.\n",
    "- Actions: 0-3 (Up, Down, Left, Right).\n",
    "- Dynamics: Deterministic transitions based on `action_map`.\n",
    "- Rewards: +10 (goal), -1 (wall), -0.1 (step).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import libraries. We primarily need `math`, `random`, `copy` (for simulation states), and `collections` or classes for the tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "import copy # For deep copying states during simulation\n",
    "from collections import defaultdict\n",
    "from typing import Tuple, Dict, Any, List, Optional, Set\n",
    "\n",
    "# Set random seeds for reproducibility\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Custom Environment\n",
    "\n",
    "Using the `GridEnvironmentTabular` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GridEnvironmentTabular:\n",
    "    \"\"\" Grid World returning state tuples, with added state copy method. \"\"\"\n",
    "    def __init__(self, rows: int = 10, cols: int = 10) -> None:\n",
    "        self.rows: int = rows\n",
    "        self.cols: int = cols\n",
    "        self.start_state: Tuple[int, int] = (0, 0)\n",
    "        self.goal_state: Tuple[int, int] = (rows - 1, cols - 1)\n",
    "        # Internal state variable - MCTS will operate on copies\n",
    "        self._internal_state: Tuple[int, int] = self.start_state \n",
    "        self.action_dim: int = 4\n",
    "        self.action_map: Dict[int, Tuple[int, int]] = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}\n",
    "        self.actions = list(self.action_map.keys())\n",
    "\n",
    "    def reset(self) -> Tuple[int, int]:\n",
    "        \"\"\" Resets environment, returns state tuple. \"\"\"\n",
    "        self._internal_state = self.start_state\n",
    "        return self._internal_state\n",
    "\n",
    "    def get_state(self) -> Tuple[int, int]:\n",
    "        \"\"\" Returns the current internal state tuple. \"\"\"\n",
    "        return self._internal_state\n",
    "        \n",
    "    def set_state(self, state: Tuple[int, int]) -> None:\n",
    "        \"\"\" Manually sets the internal state (for MCTS simulation). \"\"\"\n",
    "        if 0 <= state[0] < self.rows and 0 <= state[1] < self.cols:\n",
    "            self._internal_state = state\n",
    "        else:\n",
    "            raise ValueError(f\"Invalid state {state} for grid size {self.rows}x{self.cols}\")\n",
    "\n",
    "    def get_possible_actions(self, state: Optional[Tuple[int, int]] = None) -> List[int]:\n",
    "            \"\"\" Returns a list of possible actions from the given state (or current). \"\"\"\n",
    "            # In this simple grid, all actions are always possible (walls handled in step)\n",
    "            current_state = state if state is not None else self._internal_state\n",
    "            if current_state == self.goal_state:\n",
    "                return [] # No actions from goal state\n",
    "            return [action for action in self.actions if self.simulate_step(current_state, action)[0] != current_state]\n",
    "            \n",
    "    def is_terminal(self, state: Optional[Tuple[int, int]] = None) -> bool:\n",
    "        \"\"\" Checks if the given state (or current) is terminal. \"\"\"\n",
    "        current_state = state if state is not None else self._internal_state\n",
    "        return current_state == self.goal_state\n",
    "\n",
    "    def step(self, action: int) -> Tuple[Tuple[int, int], float, bool]:\n",
    "        \"\"\" Performs one step from the current internal state. \"\"\"\n",
    "        state = self._internal_state # Use internal state\n",
    "        if state == self.goal_state:\n",
    "            return state, 0.0, True\n",
    "        \n",
    "        dr, dc = self.action_map[action]\n",
    "        current_row, current_col = state\n",
    "        next_row, next_col = current_row + dr, current_col + dc\n",
    "        \n",
    "        reward: float = -0.1 # Step cost\n",
    "        if not (0 <= next_row < self.rows and 0 <= next_col < self.cols):\n",
    "            next_row, next_col = current_row, current_col # Stay in place\n",
    "            reward = -1.0 # Wall penalty\n",
    "            \n",
    "        self._internal_state = (next_row, next_col) # Update internal state\n",
    "        next_state_tuple = self._internal_state\n",
    "        \n",
    "        done: bool = (self._internal_state == self.goal_state)\n",
    "        if done:\n",
    "            reward = 10.0 # Goal reward\n",
    "            \n",
    "        return next_state_tuple, reward, done\n",
    "\n",
    "    def simulate_step(self, current_state: Tuple[int, int], action: int) -> Tuple[Tuple[int, int], float, bool]:\n",
    "        \"\"\" Simulates a step WITHOUT changing the internal state. Needed for MCTS. \"\"\"\n",
    "        if current_state == self.goal_state:\n",
    "            return current_state, 0.0, True\n",
    "        \n",
    "        dr, dc = self.action_map[action]\n",
    "        current_row, current_col = current_state\n",
    "        next_row, next_col = current_row + dr, current_col + dc\n",
    "        \n",
    "        reward: float = -0.1\n",
    "        if not (0 <= next_row < self.rows and 0 <= next_col < self.cols):\n",
    "            next_state_tuple = current_state # Return original state if wall hit\n",
    "            reward = -1.0\n",
    "        else:\n",
    "            next_state_tuple = (next_row, next_col)\n",
    "        \n",
    "        done: bool = (next_state_tuple == self.goal_state)\n",
    "        if done:\n",
    "            reward = 10.0\n",
    "            \n",
    "        return next_state_tuple, reward, done\n",
    "\n",
    "    def get_action_space_size(self) -> int:\n",
    "        return self.action_dim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instantiate the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MCTS Grid Environment: 5x5\n",
      "Actions: 4\n",
      "Start State: (0, 0)\n",
      "Goal State: (4, 4)\n"
     ]
    }
   ],
   "source": [
    "mcts_env = GridEnvironmentTabular(rows=5, cols=5) # Use a smaller grid for faster MCTS demo\n",
    "n_actions_mcts = mcts_env.get_action_space_size()\n",
    "start_state_mcts = mcts_env.reset()\n",
    "print(f\"MCTS Grid Environment: {mcts_env.rows}x{mcts_env.cols}\")\n",
    "print(f\"Actions: {n_actions_mcts}\")\n",
    "print(f\"Start State: {start_state_mcts}\")\n",
    "print(f\"Goal State: {mcts_env.goal_state}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the MCTS Algorithm\n",
    "\n",
    "We'll define the Node structure and the four key functions: Selection, Expansion, Simulation, Backpropagation, plus the main search orchestrator.\n",
    "\n",
    "### Defining the MCTS Node\n",
    "\n",
    "A class to represent nodes in the search tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MCTSNode:\n",
    "    \"\"\" Represents a node in the Monte Carlo Tree Search. \"\"\"\n",
    "    def __init__(self, state: Tuple[int, int], parent: Optional['MCTSNode'] = None, action_that_led_here: Optional[int] = None):\n",
    "        self.state: Tuple[int, int] = state\n",
    "        self.parent: Optional[MCTSNode] = parent\n",
    "        self.action_that_led_here: Optional[int] = action_that_led_here # Action taken by parent to reach this node\n",
    "        \n",
    "        self.children: Dict[int, MCTSNode] = {} # Maps action -> child node\n",
    "        self.untried_actions: List[int] = mcts_env.get_possible_actions(state) # Actions not yet expanded from this node\n",
    "        \n",
    "        self.visit_count: int = 0\n",
    "        self.total_value: float = 0.0 # Sum of rewards from rollouts through this node\n",
    "        \n",
    "    def is_fully_expanded(self) -> bool:\n",
    "        \"\"\" Checks if all possible actions from this node have been expanded. \"\"\"\n",
    "        return len(self.untried_actions) == 0\n",
    "        \n",
    "    def is_terminal(self) -> bool:\n",
    "        \"\"\" Checks if the state represented by this node is terminal. \"\"\"\n",
    "        return mcts_env.is_terminal(self.state)\n",
    "        \n",
    "    def get_average_value(self) -> float:\n",
    "        \"\"\" Calculates the average value Q(s) for this node. \"\"\"\n",
    "        if self.visit_count == 0:\n",
    "            return 0.0 # Or perhaps -infinity or another default for unvisited\n",
    "        return self.total_value / self.visit_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection Function (Best UCB Child)\n",
    "\n",
    "Selects the child node with the highest UCT value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_best_child_uct(node: MCTSNode, exploration_constant: float) -> MCTSNode:\n",
    "    \"\"\"\n",
    "    Selects the child node with the highest UCT score.\n",
    "    UCT = Q(child) + C * sqrt(ln(N(parent)) / N(child))\n",
    "    \n",
    "    Parameters:\n",
    "    - node (MCTSNode): The parent node from which to select.\n",
    "    - exploration_constant (float): The constant C balancing exploration/exploitation.\n",
    "    \n",
    "    Returns:\n",
    "    - MCTSNode: The child node with the highest UCT value.\n",
    "    \"\"\"\n",
    "    best_score = -float('inf')\n",
    "    best_child = None\n",
    "\n",
    "    for action, child in node.children.items():\n",
    "        if child.visit_count == 0:\n",
    "            # Ensure unvisited children are selected first\n",
    "            uct_score = float('inf') \n",
    "        else:\n",
    "            exploit_term = child.get_average_value()\n",
    "            explore_term = exploration_constant * math.sqrt(\n",
    "                math.log(node.visit_count) / child.visit_count\n",
    "            )\n",
    "            uct_score = exploit_term + explore_term\n",
    "            \n",
    "        if uct_score > best_score:\n",
    "            best_score = uct_score\n",
    "            best_child = child\n",
    "            \n",
    "    if best_child is None:\n",
    "        # This should ideally not happen if the node has children\n",
    "        raise RuntimeError(\"Selection failed: No children found or error in UCT calculation.\")\n",
    "\n",
    "    return best_child"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expansion Function\n",
    "\n",
    "Expands a leaf node by adding one new child node for an untried action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def expand_node(node: MCTSNode) -> MCTSNode:\n",
    "    \"\"\"\n",
    "    Expands the given node by choosing an untried action, simulating it,\n",
    "    and adding the resulting state as a new child node.\n",
    "\n",
    "    Parameters:\n",
    "    - node (MCTSNode): The leaf node to expand.\n",
    "\n",
    "    Returns:\n",
    "    - MCTSNode: The newly created child node.\n",
    "    \"\"\"\n",
    "    if not node.untried_actions:\n",
    "        raise RuntimeError(\"Cannot expand a fully expanded node.\")\n",
    "        \n",
    "    # Choose an action to expand (e.g., the first untried one)\n",
    "    action = node.untried_actions.pop() \n",
    "    \n",
    "    # Simulate this action from the node's state using the environment model\n",
    "    next_state, _, _ = mcts_env.simulate_step(node.state, action) # We only need next state here\n",
    "    \n",
    "    # Create the new child node\n",
    "    child_node = MCTSNode(state=next_state, parent=node, action_that_led_here=action)\n",
    "    \n",
    "    # Add the child to the parent's children dictionary\n",
    "    node.children[action] = child_node\n",
    "    \n",
    "    return child_node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation (Rollout) Function\n",
    "\n",
    "Simulates an episode from a given state using a simple rollout policy (random actions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perform_rollout(start_node: MCTSNode, max_depth: int, gamma: float) -> float:\n",
    "    \"\"\"\n",
    "    Performs a Monte Carlo simulation (rollout) from the start node's state.\n",
    "    Uses a random policy for the rollout.\n",
    "\n",
    "    Parameters:\n",
    "    - start_node (MCTSNode): The node from which to start the simulation.\n",
    "    - max_depth (int): Maximum number of steps for the rollout.\n",
    "    - gamma (float): Discount factor for the rollout rewards.\n",
    "\n",
    "    Returns:\n",
    "    - float: The total discounted reward obtained during the rollout.\n",
    "    \"\"\"\n",
    "    current_state = start_node.state\n",
    "    total_discounted_reward: float = 0.0\n",
    "    current_discount: float = 1.0\n",
    "    depth = 0\n",
    "\n",
    "    while not mcts_env.is_terminal(current_state) and depth < max_depth:\n",
    "        # Choose a random action (rollout policy)\n",
    "        possible_actions = mcts_env.get_possible_actions(current_state)\n",
    "        if not possible_actions: # Should not happen if not terminal, but safe check\n",
    "            break \n",
    "        action = random.choice(possible_actions)\n",
    "        \n",
    "        # Simulate the step using the environment model\n",
    "        next_state, reward, done = mcts_env.simulate_step(current_state, action)\n",
    "        \n",
    "        total_discounted_reward += current_discount * reward\n",
    "        \n",
    "        current_state = next_state\n",
    "        current_discount *= gamma\n",
    "        depth += 1\n",
    "        \n",
    "    return total_discounted_reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backpropagation Function\n",
    "\n",
    "Updates the statistics of nodes along the path from the root to the simulation node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def backpropagate(node: MCTSNode, reward: float) -> None:\n",
    "    \"\"\"\n",
    "    Updates the visit counts and total values of nodes up the tree.\n",
    "\n",
    "    Parameters:\n",
    "    - node (MCTSNode): The node from which the simulation started.\n",
    "    - reward (float): The result (total discounted reward) of the simulation.\n",
    "    \"\"\"\n",
    "    current_node: Optional[MCTSNode] = node\n",
    "    while current_node is not None:\n",
    "        current_node.visit_count += 1\n",
    "        current_node.total_value += reward \n",
    "        # Move up to the parent node\n",
    "        current_node = current_node.parent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main MCTS Search Function\n",
    "\n",
    "Orchestrates the four steps for a given number of iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mcts_search(\n",
    "    root_state: Tuple[int, int],\n",
    "    num_simulations: int,\n",
    "    exploration_constant: float,\n",
    "    rollout_max_depth: int,\n",
    "    gamma: float\n",
    ") -> MCTSNode:\n",
    "    \"\"\"\n",
    "    Performs the Monte Carlo Tree Search (MCTS) process for a given number of simulations.\n",
    "\n",
    "    Parameters:\n",
    "    - root_state (Tuple[int, int]): The starting state for the search.\n",
    "    - num_simulations (int): The number of simulations to perform.\n",
    "    - exploration_constant (float): The exploration constant (C) used in the UCT formula.\n",
    "    - rollout_max_depth (int): The maximum depth for rollouts during the simulation phase.\n",
    "    - gamma (float): The discount factor for rewards during rollouts.\n",
    "\n",
    "    Returns:\n",
    "    - MCTSNode: The root node of the search tree after simulations.\n",
    "    \"\"\"\n",
    "    # Create the root node for the current state\n",
    "    root_node: MCTSNode = MCTSNode(state=root_state)\n",
    "\n",
    "    # Perform the specified number of simulations\n",
    "    for _ in range(num_simulations):\n",
    "        current_node: MCTSNode = root_node\n",
    "\n",
    "        # --- 1. Selection ---\n",
    "        # Traverse down the tree using UCT until a leaf node is found\n",
    "        while not current_node.is_terminal() and current_node.is_fully_expanded() and current_node.children:\n",
    "            current_node = select_best_child_uct(current_node, exploration_constant)\n",
    "\n",
    "        # --- 2. Expansion ---\n",
    "        # Expand the current node if it is not terminal and not fully expanded\n",
    "        simulation_start_node: MCTSNode = current_node\n",
    "        if not current_node.is_terminal() and not current_node.is_fully_expanded():\n",
    "            simulation_start_node = expand_node(current_node)\n",
    "\n",
    "        # --- 3. Simulation ---\n",
    "        # Perform a rollout from the expanded node and calculate the reward\n",
    "        rollout_reward: float = perform_rollout(simulation_start_node, rollout_max_depth, gamma)\n",
    "\n",
    "        # --- 4. Backpropagation ---\n",
    "        # Update the statistics of all nodes along the path to the root\n",
    "        backpropagate(simulation_start_node, rollout_reward)\n",
    "\n",
    "    # Return the root node with updated statistics\n",
    "    return root_node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing the Best Action After Search\n",
    "\n",
    "Selects the best action based on the statistics in the tree (e.g., most visited child)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose_best_mcts_action(root_node: MCTSNode) -> int:\n",
    "    \"\"\"\n",
    "    Selects the best action from the root node after MCTS is complete.\n",
    "    Typically chooses the action leading to the most visited child node.\n",
    "\n",
    "    Parameters:\n",
    "    - root_node (MCTSNode): The root of the search tree after simulations.\n",
    "\n",
    "    Returns:\n",
    "    - int: The best action to take.\n",
    "    \"\"\"\n",
    "    best_visit_count = -1\n",
    "    best_action = -1\n",
    "\n",
    "    if not root_node.children:  # If no actions were expanded (e.g., only 1 simulation)\n",
    "        # Fallback: Choose a random action if possible\n",
    "        possible_actions = mcts_env.get_possible_actions(root_node.state)\n",
    "        if possible_actions:\n",
    "            return random.choice(possible_actions)\n",
    "        else:\n",
    "            return -1  # Or handle error\n",
    "\n",
    "    # Find the action leading to the child with the highest visit count\n",
    "    for action, child in root_node.children.items():\n",
    "        if child.visit_count > best_visit_count:\n",
    "            best_visit_count = child.visit_count\n",
    "            best_action = action\n",
    "\n",
    "    if best_action == -1:\n",
    "        # Fallback if all children have 0 visits (shouldn't happen with proper MCTS)\n",
    "        possible_actions = list(root_node.children.keys())\n",
    "        if possible_actions:\n",
    "            return random.choice(possible_actions)\n",
    "        else:\n",
    "            return -1\n",
    "\n",
    "    return best_action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running MCTS as a Planner\n",
    "\n",
    "We simulate an agent acting in the environment. At each step, it uses MCTS to decide the next action.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define MCTS hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for MCTS on Custom Grid World\n",
    "NUM_SIMULATIONS = 100       # MCTS iterations per action selection (budget)\n",
    "EXPLORATION_C = 1.414       # UCT exploration constant (sqrt(2) is common)\n",
    "ROLLOUT_MAX_DEPTH = 50      # Max steps during the simulation phase\n",
    "GAMMA_MCTS = 0.99           # Discount factor for rollout rewards\n",
    "\n",
    "NUM_EPISODES_MCTS = 50      # Number of episodes to run the agent for visualization\n",
    "MAX_STEPS_PER_EPISODE_MCTS = 200 # Max steps per episode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interaction Loop using MCTS\n",
    "\n",
    "The main loop where the agent interacts with the environment, using MCTS at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting MCTS Agent Interaction (Simulations per step=100)...\n",
      "Episode 10/50 | Avg Reward (last 10): 6.64 | Avg Length: 34.6\n",
      "Episode 20/50 | Avg Reward (last 10): 6.80 | Avg Length: 33.0\n",
      "Episode 30/50 | Avg Reward (last 10): 6.54 | Avg Length: 35.6\n",
      "Episode 40/50 | Avg Reward (last 10): 3.21 | Avg Length: 58.8\n",
      "Episode 50/50 | Avg Reward (last 10): 7.50 | Avg Length: 26.0\n",
      "MCTS Agent Interaction Finished.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Starting MCTS Agent Interaction (Simulations per step={NUM_SIMULATIONS})...\")\n",
    "\n",
    "# --- MCTS Interaction Loop ---\n",
    "mcts_run_rewards = []\n",
    "mcts_run_lengths = []\n",
    "\n",
    "for i_episode in range(1, NUM_EPISODES_MCTS + 1):\n",
    "    state: Tuple[int, int] = mcts_env.reset()\n",
    "    episode_reward: float = 0.0\n",
    "    episode_path: List[Tuple[int, int]] = [state] # Store path for visualization\n",
    "    \n",
    "    for t in range(MAX_STEPS_PER_EPISODE_MCTS):\n",
    "        if mcts_env.is_terminal(state):\n",
    "            break # Already at goal\n",
    "        \n",
    "        # --- Use MCTS to choose the best action --- \n",
    "        root_node = mcts_search(state, NUM_SIMULATIONS, EXPLORATION_C, \n",
    "                                ROLLOUT_MAX_DEPTH, GAMMA_MCTS)\n",
    "        action = choose_best_mcts_action(root_node)\n",
    "        # --- ------------------------------------ ---\n",
    "        \n",
    "        if action == -1: # Should not happen in this grid world unless goal reached\n",
    "            print(f\"Warning: MCTS returned invalid action (-1) at state {state}.\")\n",
    "            break\n",
    "\n",
    "        # Take the chosen action in the real environment\n",
    "        next_state, reward, done = mcts_env.step(action) # Use step() to advance env state\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        episode_path.append(state)\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # --- End of Episode --- \n",
    "    mcts_run_rewards.append(episode_reward)\n",
    "    mcts_run_lengths.append(t + 1)\n",
    "    \n",
    "    # Print progress\n",
    "    if i_episode % 10 == 0:\n",
    "        avg_reward = np.mean(mcts_run_rewards[-10:])\n",
    "        avg_length = np.mean(mcts_run_lengths[-10:])\n",
    "        print(f\"Episode {i_episode}/{NUM_EPISODES_MCTS} | Avg Reward (last 10): {avg_reward:.2f} | Avg Length: {avg_length:.1f}\")\n",
    "\n",
    "print(\"MCTS Agent Interaction Finished.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Process\n",
    "\n",
    "Plot the episode rewards and lengths achieved by the agent using MCTS for planning.\n",
    "\n",
    "### Visualizing an Agent's Path\n",
    "We can also plot the path taken in the last episode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for MCTS Agent Runs\n",
    "plt.figure(figsize=(20, 5))\n",
    "\n",
    "# Rewards\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(mcts_run_rewards)\n",
    "plt.title(f'MCTS Agent: Episode Rewards (Sims={NUM_SIMULATIONS})')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')\n",
    "plt.grid(True)\n",
    "if len(mcts_run_rewards) >= 10:\n",
    "    rewards_ma_mcts = np.convolve(mcts_run_rewards, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(rewards_ma_mcts)) + 9, rewards_ma_mcts, label='10-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Lengths\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(mcts_run_lengths)\n",
    "plt.title(f'MCTS Agent: Episode Lengths (Sims={NUM_SIMULATIONS})')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Steps')\n",
    "plt.grid(True)\n",
    "if len(mcts_run_lengths) >= 10:\n",
    "    lengths_ma_mcts = np.convolve(mcts_run_lengths, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(lengths_ma_mcts)) + 9, lengths_ma_mcts, label='10-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Path Visualization\n",
    "plt.subplot(1, 3, 3)\n",
    "if 'episode_path' in locals() and episode_path:\n",
    "    rows = mcts_env.rows\n",
    "    cols = mcts_env.cols\n",
    "    path_grid = np.zeros((rows, cols))\n",
    "    for i, (r, c) in enumerate(episode_path):\n",
    "        path_grid[r, c] = i + 1 # Mark path order\n",
    "        \n",
    "    plt.imshow(path_grid, cmap='viridis')\n",
    "    plt.title(f\"MCTS Agent Path - Last Episode (Episode {NUM_EPISODES_MCTS})\")\n",
    "    plt.colorbar(label='Step Order')\n",
    "    \n",
    "    # Mark start and goal\n",
    "    start_r, start_c = mcts_env.start_state\n",
    "    goal_r, goal_c = mcts_env.goal_state\n",
    "    plt.text(start_c, start_r, 'S', ha='center', va='center', color='red', weight='bold', fontsize=12)\n",
    "    plt.text(goal_c, goal_r, 'G', ha='center', va='center', color='white', weight='bold', fontsize=12)\n",
    "else:\n",
    "    plt.text(0.5, 0.5, \"No path data available to visualize.\", ha='center', va='center')\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of MCTS Agent Curves (Grid World, Sims=100):**\n",
    "\n",
    "1.  **Episode Rewards & Lengths:**\n",
    "    The agent generally achieves high rewards and finds relatively short paths, as indicated by the moving averages settling near the optimal reward range and low step counts (~20-25). However, both metrics show significant episode-to-episode volatility (e.g., the large reward dip and corresponding length spike around episode 32). This variance is characteristic of MCTS, as it relies on stochastic simulations within its planning phase at each step, rather than converging stable learned values like Q-learning.\n",
    "\n",
    "2.  **Agent Path (Last Episode):**\n",
    "    The visualized path for the final episode confirms that MCTS finds a successful path to the goal. However, the path taken (34 steps in this case for a 5x5 grid where optimal is 8) is clearly suboptimal. This highlights that while MCTS can solve the problem, the quality of the path found in any single episode depends heavily on the search performed *during that episode*, and it doesn't guarantee finding the globally shortest path consistently without a very large number of simulations.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "MCTS, functioning as a planning algorithm using 100 simulations per step, effectively finds goal-reaching policies in the Grid World on average. Its performance is strong but exhibits higher variance and less consistent path optimality compared to value/policy *learning* methods. This demonstrates MCTS's strength in leveraging a model (implicit simulator) for planning but also its sensitivity to the stochasticity and budget of its search process within each episode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Plotting MCTS Derived Policy (takes time):\n",
      "Deriving policy grid (this might take a while)...\n",
      "  Row 1/5 complete.\n",
      "  Row 2/5 complete.\n",
      "  Row 3/5 complete.\n",
      "  Row 4/5 complete.\n",
      "  Row 5/5 complete.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_mcts_derived_policy(env: GridEnvironmentTabular,\n",
    "                             num_simulations: int, \n",
    "                             exploration_constant: float, \n",
    "                             rollout_max_depth: int, \n",
    "                             gamma: float) -> None:\n",
    "    \"\"\" Derives and plots the policy by running MCTS from each state. \"\"\"\n",
    "    rows: int = env.rows\n",
    "    cols: int = env.cols\n",
    "    policy_grid: np.ndarray = np.empty((rows, cols), dtype=str)\n",
    "    action_symbols: Dict[int, str] = {0: '↑', 1: '↓', 2: '←', 3: '→'}\n",
    "\n",
    "    print(\"Deriving policy grid (this might take a while)...\")\n",
    "    fig, ax = plt.subplots(figsize=(cols * 0.6, rows * 0.6))\n",
    "\n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            state: Tuple[int, int] = (r, c)\n",
    "            if env.is_terminal(state):\n",
    "                policy_grid[r, c] = 'G'\n",
    "                ax.text(c, r, 'G', ha='center', va='center', color='green', fontsize=12, weight='bold')\n",
    "            else:\n",
    "                # Run MCTS from this state to find the best action\n",
    "                root_node = mcts_search(state, num_simulations, exploration_constant, \n",
    "                                        rollout_max_depth, gamma)\n",
    "                best_action = choose_best_mcts_action(root_node)\n",
    "                \n",
    "                if best_action != -1:\n",
    "                    symbol = action_symbols[best_action]\n",
    "                else: # Should only happen if state has no possible actions (not the case here except goal)\n",
    "                    symbol = '?' \n",
    "                    \n",
    "                policy_grid[r, c] = symbol\n",
    "                ax.text(c, r, symbol, ha='center', va='center', color='black', fontsize=12)\n",
    "        print(f\"  Row {r+1}/{rows} complete.\") # Progress indicator\n",
    "\n",
    "    ax.matshow(np.zeros((rows, cols)), cmap='Greys', alpha=0.1)\n",
    "    ax.set_xticks(np.arange(-.5, cols, 1), minor=True)\n",
    "    ax.set_yticks(np.arange(-.5, rows, 1), minor=True)\n",
    "    ax.grid(which='minor', color='black', linestyle='-', linewidth=1)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_title(f\"MCTS Derived Policy (Sims={num_simulations})\")\n",
    "    plt.show()\n",
    "\n",
    "# Plot the derived policy (might be slow for large grids/simulations)\n",
    "print(\"\\nPlotting MCTS Derived Policy (takes time):\")\n",
    "plot_mcts_derived_policy(mcts_env, NUM_SIMULATIONS // 10, EXPLORATION_C, \n",
    "                         ROLLOUT_MAX_DEPTH // 2, GAMMA_MCTS) # Use fewer sims for faster plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Extensions of MCTS\n",
    "\n",
    "**Challenge: Computational Cost**\n",
    "*   **Problem:** Running many simulations per step can be computationally intensive, limiting real-time application.\n",
    "*   **Solutions**:\n",
    "    *   **Parallelization:** Run simulations in parallel (on multiple cores/machines).\n",
    "    *   **Budget Tuning:** Adjust the number of simulations based on available time.\n",
    "    * **Better Rollout Policies:** More informed rollout policies can lead to better value estimates with fewer simulations.\n",
    "    * **Function Approximation (e.g., AlphaZero):** Use neural networks to provide prior probabilities for action selection (guiding the search) and to evaluate leaf nodes directly, reducing the need for deep rollouts.\n",
    "\n",
    "**Challenge: High Branching Factor**\n",
    "*   **Problem:** If there are many possible actions at each state, exploring them all during expansion becomes difficult.\n",
    "   **Solutions**:\n",
    "    *   **Progressive Widening (UCT for Continuous Actions):** Limit the number of actions expanded at a node based on visit counts.\n",
    "    *   **Policy Guidance:** Use a learned policy network (like in AlphaZero) to suggest promising actions to explore first.\n",
    "\n",
    "**Challenge: Simulation Quality**\n",
    "*   **Problem:** The accuracy of MCTS relies on the value estimates from rollouts. Random rollouts can be very high variance, especially in environments with sparse rewards or long horizons.\n",
    "   **Solutions**:\n",
    "    *   **Domain-Specific Rollout Policies:** Incorporate simple heuristics if available.\n",
    "    *   **Value Network Integration:** Evaluate leaf nodes using a learned value function instead of performing full rollouts.\n",
    "\n",
    "**Challenge: Large State Spaces**\n",
    "*   **Problem:** In very large or continuous state spaces, representing the tree explicitly becomes infeasible, and the same state might rarely be visited twice.\n",
    "   **Solutions**:\n",
    "    *   **State Abstraction/Discretization:** Group similar states (can lose information).\n",
    "    *   **Function Approximation:** Use neural networks to represent policy/value estimates within the MCTS framework (e.g., AlphaZero, MuZero).\n",
    "\n",
    "**Extensions:**\n",
    "- **RAVE (Rapid Action Value Estimation):** Uses statistics from sibling nodes to improve value estimates.\n",
    "- **Progressive Widening:** Handles large/continuous action spaces.\n",
    "- **AlphaGo/AlphaZero/MuZero:** Combine MCTS with deep neural networks for policy and value estimation, and potentially model learning.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Monte Carlo Tree Search (MCTS) is a powerful online planning algorithm that effectively balances exploration and exploitation to find good actions in complex decision-making problems. By iteratively building a search tree guided by simulated outcomes (rollouts), it can handle large state spaces and branching factors without requiring an explicit heuristic evaluation function.\n",
    "\n",
    "Its success, particularly in game playing like Go, highlights its strength in domains where a simulator is available. While basic MCTS uses random rollouts, its true power often emerges when combined with domain knowledge or learned components (like policy and value networks in AlphaZero) to guide the search and simulations more effectively. Understanding MCTS provides a foundation for tackling complex planning problems and appreciating the synergy between search, simulation, and learning in artificial intelligence."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
